home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume19 / dmake / part27 < prev    next >
Encoding:
Text File  |  1991-05-12  |  40.1 KB  |  1,437 lines
  1. Newsgroups: comp.sources.misc
  2. From: Dennis Vadura <dvadura@watdragon.waterloo.edu>
  3. Subject:  v19i048:  dmake - dmake version 3.7, Part27/37
  4. Message-ID: <1991May12.221544.16521@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 453cc392a39daffdc420fc8b6292518e
  6. Date: Sun, 12 May 1991 22:15:44 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: Dennis Vadura <dvadura@watdragon.waterloo.edu>
  10. Posting-number: Volume 19, Issue 48
  11. Archive-name: dmake/part27
  12. Supersedes: dmake-3.6: Volume 15, Issue 52-77
  13.  
  14. ---- Cut Here and feed the following to sh ----
  15. #!/bin/sh
  16. # this is dmake.shar.27 (part 27 of a multipart archive)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file dmake/os2/mscdos/public.h continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 27; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test -f _shar_wnt_.tmp; then
  33. sed 's/^X//' << 'SHAR_EOF' >> 'dmake/os2/mscdos/public.h' &&
  34. void Catch_signals ANSI((void (*)()));
  35. void Clear_signals ANSI(());
  36. void Prolog ANSI((int, char* []));
  37. void Epilog ANSI((int));
  38. char * Get_current_dir ANSI(());
  39. int Set_dir ANSI((char*));
  40. char Get_switch_char ANSI(());
  41. FILE* Get_temp ANSI((char **, char *, int));
  42. FILE * Start_temp ANSI((char *, CELLPTR, char **));
  43. void Open_temp_error ANSI((char *, char *));
  44. void Link_temp ANSI((CELLPTR, FILE *, char *));
  45. void Close_temp ANSI((CELLPTR, FILE *));
  46. void Unlink_temp_files ANSI((CELLPTR));
  47. void Handle_result ANSI((int, int, int, CELLPTR));
  48. void Update_time_stamp ANSI((CELLPTR));
  49. void Parse ANSI((FILE *));
  50. int Get_line ANSI((char *, FILE *));
  51. char * Do_comment ANSI((char *, char **, int));
  52. char * Get_token ANSI((TKSTRPTR, char *, int));
  53. void Quit ANSI(());
  54. void Read_state ANSI(());
  55. void Write_state ANSI(());
  56. int Check_state ANSI((CELLPTR, STRINGPTR *, int));
  57. char* basename ANSI((char *));
  58. void Dump ANSI(());
  59. void Dump_recipe ANSI((STRINGPTR));
  60. int Parse_macro ANSI((char *, int));
  61. int Macro_op ANSI((char *));
  62. int Parse_rule_def ANSI((int *));
  63. int Rule_op ANSI((char *));
  64. void Add_recipe_to_list ANSI((char *, int, int));
  65. void Bind_rules_to_targets ANSI((int));
  66. int Set_group_attributes ANSI((char *));
  67. DFALINKPTR Match_dfa ANSI((char *));
  68. void Check_circle_dfa ANSI(());
  69. void Add_nfa ANSI((char *));
  70. char * Exec_function ANSI((char *));
  71. int runargv ANSI((CELLPTR, int, int, int, int, char *));
  72. void SetSessionTitle ANSI(());
  73. int Wait_for_child ANSI((int, int));
  74. void Clean_up_processes ANSI(());
  75. int _chdir ANSI((char *));
  76. int If_root_path ANSI((char *));
  77. time_t seek_arch ANSI((char*, char*));
  78. int touch_arch ANSI((char*, char*));
  79. void Remove_prq ANSI((CELLPTR));
  80. X
  81. #endif
  82. SHAR_EOF
  83. chmod 0640 dmake/os2/mscdos/public.h ||
  84. echo 'restore of dmake/os2/mscdos/public.h failed'
  85. Wc_c="`wc -c < 'dmake/os2/mscdos/public.h'`"
  86. test 5614 -eq "$Wc_c" ||
  87.     echo 'dmake/os2/mscdos/public.h: original size 5614, current size' "$Wc_c"
  88. rm -f _shar_wnt_.tmp
  89. fi
  90. # ============= dmake/os2/mscdos/startup.mk ==============
  91. if test -f 'dmake/os2/mscdos/startup.mk' -a X"$1" != X"-c"; then
  92.     echo 'x - skipping dmake/os2/mscdos/startup.mk (File already exists)'
  93.     rm -f _shar_wnt_.tmp
  94. else
  95. > _shar_wnt_.tmp
  96. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/mscdos/startup.mk' &&
  97. #NOTE:  startup.mk file is called dmake.ini for OS/2
  98. #       and is found in os2/mscdos/dmake.ini
  99. .INCLUDE : "os2/mscdos/dmake.ini"
  100. SHAR_EOF
  101. chmod 0640 dmake/os2/mscdos/startup.mk ||
  102. echo 'restore of dmake/os2/mscdos/startup.mk failed'
  103. Wc_c="`wc -c < 'dmake/os2/mscdos/startup.mk'`"
  104. test 132 -eq "$Wc_c" ||
  105.     echo 'dmake/os2/mscdos/startup.mk: original size 132, current size' "$Wc_c"
  106. rm -f _shar_wnt_.tmp
  107. fi
  108. # ============= dmake/os2/mscdos/tempnam.c ==============
  109. if test -f 'dmake/os2/mscdos/tempnam.c' -a X"$1" != X"-c"; then
  110.     echo 'x - skipping dmake/os2/mscdos/tempnam.c (File already exists)'
  111.     rm -f _shar_wnt_.tmp
  112. else
  113. > _shar_wnt_.tmp
  114. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/mscdos/tempnam.c' &&
  115. /*LINTLIBRARY*/
  116. #include <stdio.h>
  117. #include <string.h>
  118. #include <stdlib.h>
  119. #include <dos.h>
  120. X
  121. #if defined(max)
  122. #   undef  max
  123. #endif
  124. #define max(A,B) (((A)<(B))?(B):(A))
  125. X
  126. extern int access();
  127. int _access();
  128. X
  129. /* MSC stdio.h defines P_tmpdir, so let's undo it here */
  130. /* Under DOS leave the default tmpdir pointing here!        */
  131. #ifdef P_tmpdir
  132. #undef P_tmpdir
  133. #endif
  134. static char *P_tmpdir = "";
  135. X
  136. char *
  137. tempnam(dir, prefix)
  138. char *dir;        /* use this directory please (if non-NULL) */
  139. char *prefix;        /* use this (if non-NULL) as filename prefix */
  140. {
  141. X   static         int count = 0;
  142. X   register char *p, *q, *tmpdir;
  143. X   int            tl=0, dl=0, pl;
  144. X   char          buf[30];
  145. X
  146. X   pl = strlen(P_tmpdir);
  147. X
  148. X   if( (tmpdir = getenv("TMPDIR")) != NULL )
  149. X      tl = strlen(tmpdir);
  150. X   else if( (tmpdir = getenv("TMP")) != NULL )
  151. X      tl = strlen(tmpdir);
  152. X   if( dir != NULL ) dl = strlen(dir);
  153. X
  154. X   if( (p = malloc((unsigned)(max(max(dl,tl),pl)+13))) == NULL )
  155. X     return(NULL);
  156. X
  157. X   *p = '\0';
  158. X
  159. X   if( (tl == 0) || (_access( strcpy(p, tmpdir), 0) != 0) )
  160. X     if( (dl == 0) || (_access( strcpy(p, dir), 0) != 0) )
  161. X    if( _access( strcpy(p, P_tmpdir), 0) != 0 )
  162. X       if( !prefix )
  163. X          prefix = "tp";
  164. X
  165. X   if(prefix)
  166. X   {
  167. X      *(p+strlen(p)+2) = '\0';
  168. X      (void)strncat(p, prefix, 2);
  169. X   }
  170. X
  171. #ifdef OS2
  172. X   sprintf( buf, "%08x", getpid() );
  173. #else
  174. X   sprintf( buf, "%08x", _psp );
  175. #endif
  176. X   buf[6]='\0';
  177. X   (void)strcat(p, buf );
  178. X   sprintf( buf, "%04d", count++ );
  179. X   q=p+strlen(p)-6;
  180. X   *q++ = buf[0]; *q++ = buf[1];
  181. X   *q++ = buf[2]; *q++ = buf[3];
  182. X
  183. X   if( (q = strrchr(p,'.')) != NULL ) *q = '\0';
  184. X
  185. X   return strlwr(p);
  186. }
  187. X
  188. X
  189. X
  190. _access( name, flag )
  191. char *name;
  192. int  flag;
  193. {
  194. X   char *p;
  195. X   int r;
  196. X
  197. X   if( name == NULL || !*name ) return(1);  /* NULL dir means current dir */
  198. X   p = name+strlen(name)-1;
  199. X   if(*p == ':' ) strcat( p++, "\\" );
  200. X   r = access( name, flag );
  201. X   if(*p != '/' && *p != '\\') strcat( p, "\\" );
  202. X
  203. X   return( r );
  204. }
  205. SHAR_EOF
  206. chmod 0640 dmake/os2/mscdos/tempnam.c ||
  207. echo 'restore of dmake/os2/mscdos/tempnam.c failed'
  208. Wc_c="`wc -c < 'dmake/os2/mscdos/tempnam.c'`"
  209. test 1919 -eq "$Wc_c" ||
  210.     echo 'dmake/os2/mscdos/tempnam.c: original size 1919, current size' "$Wc_c"
  211. rm -f _shar_wnt_.tmp
  212. fi
  213. # ============= dmake/os2/ruletab.c ==============
  214. if test -f 'dmake/os2/ruletab.c' -a X"$1" != X"-c"; then
  215.     echo 'x - skipping dmake/os2/ruletab.c (File already exists)'
  216.     rm -f _shar_wnt_.tmp
  217. else
  218. > _shar_wnt_.tmp
  219. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/ruletab.c' &&
  220. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/os2/RCS/ruletab.c,v 1.1 91/05/06 15:33:22 dvadura Exp $
  221. -- SYNOPSIS -- Default initial configuration of dmake.
  222. -- 
  223. -- DESCRIPTION
  224. --     Define here the initial set of rules that are defined before
  225. --    dmake performs any processing.
  226. --
  227. -- AUTHOR
  228. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  229. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  230. --
  231. -- COPYRIGHT
  232. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  233. -- 
  234. --      This program is free software; you can redistribute it and/or
  235. --      modify it under the terms of the GNU General Public License
  236. --      (version 1), as published by the Free Software Foundation, and
  237. --      found in the file 'LICENSE' included with this distribution.
  238. -- 
  239. --      This program is distributed in the hope that it will be useful,
  240. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  241. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  242. --      GNU General Public License for more details.
  243. -- 
  244. --      You should have received a copy of the GNU General Public License
  245. --      along with this program;  if not, write to the Free Software
  246. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  247. --
  248. -- LOG
  249. --     $Log:    ruletab.c,v $
  250. X * Revision 1.1  91/05/06  15:33:22  dvadura
  251. X * dmake Release Version 3.7
  252. X * 
  253. */
  254. X
  255. /* These are control macros for dmake that MUST be defined at some point
  256. X * if they are NOT dmake will not work!  These are default definitions.  They
  257. X * may be overridden inside the .STARTUP makefile, they are here
  258. X * strictly so that dmake can parse the STARTUP makefile */
  259. /*
  260. X * For OS/2 these are close to the Unix definitions in terms of limits.
  261. X * We dont need the two different cases of Makefile, so only keep the
  262. X * pretty one.
  263. X */
  264. static char *_rules[] = {
  265. X    "MAXLINELENGTH := 2046",
  266. X    "MAXPROCESSLIMIT := 16",
  267. X    ".IMPORT .IGNORE: ROOTDIR INIT",
  268. X    ".MAKEFILES : makefile.mk Makefile",
  269. X    ".SOURCE    : .NULL",
  270. #include "startup.h"
  271. X    0 };
  272. X
  273. char **Rule_tab = _rules; /* for sundry reasons in Get_environment() */
  274. X
  275. SHAR_EOF
  276. chmod 0640 dmake/os2/ruletab.c ||
  277. echo 'restore of dmake/os2/ruletab.c failed'
  278. Wc_c="`wc -c < 'dmake/os2/ruletab.c'`"
  279. test 2098 -eq "$Wc_c" ||
  280.     echo 'dmake/os2/ruletab.c: original size 2098, current size' "$Wc_c"
  281. rm -f _shar_wnt_.tmp
  282. fi
  283. # ============= dmake/os2/runargv.c ==============
  284. if test -f 'dmake/os2/runargv.c' -a X"$1" != X"-c"; then
  285.     echo 'x - skipping dmake/os2/runargv.c (File already exists)'
  286.     rm -f _shar_wnt_.tmp
  287. else
  288. > _shar_wnt_.tmp
  289. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/runargv.c' &&
  290. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/os2/RCS/runargv.c,v 1.1 91/05/06 15:33:22 dvadura Exp $
  291. -- SYNOPSIS -- invoke a sub process, modified unix/runargv.c for OS/2.
  292. -- 
  293. -- DESCRIPTION
  294. --     Use the standard methods of executing a sub process.
  295. --
  296. -- AUTHOR
  297. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  298. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  299. --
  300. -- COPYRIGHT
  301. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  302. -- 
  303. --      This program is free software; you can redistribute it and/or
  304. --      modify it under the terms of the GNU General Public License
  305. --      (version 1), as published by the Free Software Foundation, and
  306. --      found in the file 'LICENSE' included with this distribution.
  307. -- 
  308. --      This program is distributed in the hope that it will be useful,
  309. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  310. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  311. --      GNU General Public License for more details.
  312. -- 
  313. --      You should have received a copy of the GNU General Public License
  314. --      along with this program;  if not, write to the Free Software
  315. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  316. --
  317. -- LOG
  318. --     $Log:    runargv.c,v $
  319. X * Revision 1.1  91/05/06  15:33:22  dvadura
  320. X * dmake Release Version 3.7
  321. X * 
  322. */
  323. X
  324. #define INCL_DOSPROCESS
  325. #include <os2.h>
  326. X
  327. #include <process.h>
  328. #include <stdlib.h>
  329. #include <signal.h>
  330. #include "extern.h"
  331. #include "sysintf.h"
  332. X
  333. typedef struct prp {
  334. X   char *prp_cmd;
  335. X   int   prp_group;
  336. X   int   prp_ignore;
  337. X   int   prp_last;
  338. X   int     prp_shell;
  339. X   struct prp *prp_next;
  340. } RCP, *RCPPTR;
  341. X
  342. typedef struct pr {
  343. X   int        pr_valid;
  344. X   int        pr_pid;
  345. X   CELLPTR    pr_target;
  346. X   int        pr_ignore;
  347. X   int        pr_last;
  348. X   RCPPTR      pr_recipe;
  349. X   RCPPTR      pr_recipe_end;
  350. X   char        *pr_dir;
  351. } PR;
  352. X
  353. static PR  *_procs    = NIL(PR);
  354. static int  _proc_cnt = 0;
  355. static int  _abort_flg= FALSE;
  356. static int  _use_i    = -1;
  357. static int  _do_upd   = 0;
  358. X
  359. extern unsigned int _far _pascal DosSmSetTitle(char _far *s);
  360. static  void    SetSessionTitle (char *s);
  361. static  void    _add_child ANSI((int, CELLPTR, int, int));
  362. static  void    _attach_cmd ANSI((char *, int, int, CELLPTR, int, int));
  363. static  void    _finished_child ANSI((int, int));
  364. static  int     _running ANSI((CELLPTR));
  365. X
  366. PUBLIC int
  367. runargv(target, ignore, group, last, shell, cmd)
  368. CELLPTR target;
  369. int     ignore;
  370. int    group;
  371. int    last;
  372. int     shell;
  373. char    *cmd;
  374. {
  375. X   int          pid;
  376. X   char         **argv;
  377. X
  378. X   if( _running(target) /*&& Max_proc != 1*/ ) {
  379. X      /* The command will be executed when the previous recipe
  380. X       * line completes. */
  381. X      _attach_cmd( cmd, group, ignore, target, last, shell );
  382. X      return(1);
  383. X   }
  384. X
  385. X   while( _proc_cnt == Max_proc )
  386. X      if( Wait_for_child(FALSE, -1) == -1 )  Fatal( "Lost a child" );
  387. X
  388. #ifdef SESSTITLE
  389. X   SetSessionTitle(target->CE_NAME);
  390. #endif
  391. X   argv = Pack_argv( group, shell, cmd );
  392. X
  393. X   if((pid=spawnvp((_osmode == DOS_MODE)?P_WAIT:P_NOWAIT,argv[0],argv)) == -1){
  394. X      Error("%s: %s", argv[0], sys_errlist[errno]);
  395. X      Handle_result(-1, ignore, _abort_flg, target);
  396. X      return(-1);
  397. X   }
  398. X   else if( _osmode == DOS_MODE ) {
  399. X     _add_child(4711, target, ignore, last);
  400. X     _finished_child(4711, pid);
  401. X   }
  402. X   else
  403. X     _add_child(pid, target, ignore, last);
  404. X
  405. X   return(1);
  406. }
  407. X
  408. X
  409. #ifdef SESSTITLE
  410. /* N.B. The system call used below is undocumented and therefore possibly
  411. X * subject to change. It sets the session title even from a full screen
  412. X * session, so you can see which target is being built.
  413. X * If dubious about undocumented calls simply remove it.
  414. X */
  415. PUBLIC void
  416. SetSessionTitle(char *s)
  417. {
  418. X   char buff[128];
  419. X   strncpy(buff, Pname, sizeof(buff));
  420. X   buff[sizeof(buff)-1] = 0;
  421. X   strncat(buff, " - ", sizeof(buff));
  422. X   strncat(buff, s, sizeof(buff));
  423. X   buff[sizeof(buff)-1] = 0;
  424. X   DosSmSetTitle(buff);
  425. }
  426. #endif
  427. X
  428. X
  429. PUBLIC int
  430. Wait_for_child( abort_flg, pid )
  431. int abort_flg;
  432. int pid;
  433. {
  434. X   int wid;
  435. X   int status;
  436. X   int waitchild;
  437. X
  438. X   if( _osmode == DOS_MODE ) return(1);
  439. X
  440. X   waitchild = (pid == -1)? FALSE : Wait_for_completion;
  441. X
  442. X   do {
  443. X      if( (wid = wait(&status)) == -1 ) return(-1);
  444. X
  445. X      _abort_flg = abort_flg;
  446. X      _finished_child(wid, status);
  447. X      _abort_flg = FALSE;
  448. X   }
  449. X   while( waitchild && pid != wid );
  450. X
  451. X   return(0);
  452. }
  453. X
  454. X
  455. PUBLIC void
  456. Clean_up_processes()
  457. {
  458. X   register int i;
  459. X
  460. X   if( _osmode == DOS_MODE ) {
  461. X      _abort_flg = TRUE;
  462. X      _finished_child(4711, -1);
  463. X      return;
  464. X   }
  465. X
  466. X   if( _procs != NIL(PR) ) {
  467. X      for( i=0; i<Max_proc; i++ )
  468. X     if( _procs[i].pr_valid )
  469. X        DosKillProcess(DKP_PROCESSTREE, _procs[i].pr_pid);
  470. X
  471. X      while( Wait_for_child(TRUE, -1) != -1 );
  472. X   }
  473. }
  474. X
  475. X
  476. static void
  477. _add_child( pid, target, ignore, last )
  478. int    pid;
  479. CELLPTR target;
  480. int    ignore;
  481. int     last;
  482. {
  483. X   register int i;
  484. X   register PR *pp;
  485. X
  486. X   if( _procs == NIL(PR) ) {
  487. X      TALLOC( _procs, Max_proc, PR );
  488. X   }
  489. X
  490. X   if( (i = _use_i) == -1 )
  491. X      for( i=0; i<Max_proc; i++ )
  492. X     if( !_procs[i].pr_valid )
  493. X        break;
  494. X
  495. X   pp = _procs+i;
  496. X
  497. X   pp->pr_valid  = 1;
  498. X   pp->pr_pid    = pid;
  499. X   pp->pr_target = target;
  500. X   pp->pr_ignore = ignore;
  501. X   pp->pr_last   = last;
  502. X   pp->pr_dir    = _strdup(Get_current_dir());
  503. X
  504. X   Current_target = NIL(CELL);
  505. X
  506. X   _proc_cnt++;
  507. X
  508. X   if( Wait_for_completion ) Wait_for_child( FALSE, pid );
  509. }
  510. X
  511. X
  512. static void
  513. _finished_child(pid, status)
  514. int    pid;
  515. int    status;
  516. {
  517. X   register int i;
  518. X   register PR *pp;
  519. X   char     *dir;
  520. X
  521. X   for( i=0; i<Max_proc; i++ )
  522. X      if( _procs[i].pr_valid && _procs[i].pr_pid == pid )
  523. X     break;
  524. X
  525. X   /* Some children we didn't make esp true if using /bin/sh to execute a
  526. X    * a pipe and feed the output as a makefile into dmake. */
  527. X   if( i == Max_proc ) return;
  528. X   _procs[i].pr_valid = 0;
  529. X   _proc_cnt--;
  530. X   dir = _strdup(Get_current_dir());
  531. X   Set_dir( _procs[i].pr_dir );
  532. X
  533. X   if( _procs[i].pr_recipe != NIL(RCP) && !_abort_flg ) {
  534. X      RCPPTR rp = _procs[i].pr_recipe;
  535. X
  536. X
  537. X      Current_target = _procs[i].pr_target;
  538. X      Handle_result( status, _procs[i].pr_ignore, FALSE, _procs[i].pr_target );
  539. X      Current_target = NIL(CELL);
  540. X
  541. X      _procs[i].pr_recipe = rp->prp_next;
  542. X
  543. X      _use_i = i;
  544. X      runargv( _procs[i].pr_target, rp->prp_ignore, rp->prp_group,
  545. X           rp->prp_last, rp->prp_shell, rp->prp_cmd );
  546. X      _use_i = -1;
  547. X
  548. X      FREE( rp->prp_cmd );
  549. X      FREE( rp );
  550. X
  551. X      if( _proc_cnt == Max_proc ) Wait_for_child( FALSE, -1 );
  552. X   }
  553. X   else {
  554. X      Unlink_temp_files( _procs[i].pr_target );
  555. X      Handle_result(status,_procs[i].pr_ignore,_abort_flg,_procs[i].pr_target);
  556. X
  557. X      if( _procs[i].pr_last ) {
  558. X     FREE(_procs[i].pr_dir );
  559. X
  560. X     if( !Doing_bang ) Update_time_stamp( _procs[i].pr_target );
  561. X      }
  562. X   }
  563. X
  564. X   Set_dir(dir);
  565. X   FREE(dir);
  566. }
  567. X
  568. X
  569. static int
  570. _running( cp )
  571. CELLPTR cp;
  572. {
  573. X   register int i;
  574. X
  575. X   if( !_procs ) return(FALSE);
  576. X
  577. X   for( i=0; i<Max_proc; i++ )
  578. X      if( _procs[i].pr_valid &&
  579. X      _procs[i].pr_target == cp  )
  580. X     break;
  581. X     
  582. X   return( i != Max_proc );
  583. }
  584. X
  585. X
  586. static void
  587. _attach_cmd( cmd, group, ignore, cp, last, shell )
  588. char    *cmd;
  589. int    group;
  590. int     ignore;
  591. CELLPTR cp;
  592. int     last;
  593. int     shell;
  594. {
  595. X   register int i;
  596. X   RCPPTR rp;
  597. X
  598. X   for( i=0; i<Max_proc; i++ )
  599. X      if( _procs[i].pr_valid &&
  600. X      _procs[i].pr_target == cp  )
  601. X     break;
  602. X
  603. X   TALLOC( rp, 1, RCP );
  604. X   rp->prp_cmd   = _strdup(cmd);
  605. X   rp->prp_group = group;
  606. X   rp->prp_ignore= ignore;
  607. X   rp->prp_last  = last;
  608. X   rp->prp_shell = shell;
  609. X   rp->prp_dir   = _strdup(Get_current_dir());
  610. X
  611. X   if( _procs[i].pr_recipe == NIL(RCP) )
  612. X      _procs[i].pr_recipe = _procs[i].pr_recipe_end = rp;
  613. X   else {
  614. X      _procs[i].pr_recipe_end->prp_next = rp;
  615. X      _procs[i].pr_recipe_end = rp;
  616. X   }
  617. }
  618. SHAR_EOF
  619. chmod 0640 dmake/os2/runargv.c ||
  620. echo 'restore of dmake/os2/runargv.c failed'
  621. Wc_c="`wc -c < 'dmake/os2/runargv.c'`"
  622. test 7611 -eq "$Wc_c" ||
  623.     echo 'dmake/os2/runargv.c: original size 7611, current size' "$Wc_c"
  624. rm -f _shar_wnt_.tmp
  625. fi
  626. # ============= dmake/os2/startup.h ==============
  627. if test -f 'dmake/os2/startup.h' -a X"$1" != X"-c"; then
  628.     echo 'x - skipping dmake/os2/startup.h (File already exists)'
  629.     rm -f _shar_wnt_.tmp
  630. else
  631. > _shar_wnt_.tmp
  632. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/startup.h' &&
  633. /* This file contains the default value of the MAKESTARTUP variable.
  634. X * You must set the quoted string below to the default path to the startup
  635. X * variable, so that it gets compiled in.  LEAVE ROOTDIR at the front of
  636. X * the path.  This allows the user to customize his environment for dmake
  637. X * by setting up a new ROOTDIR environment variable. */
  638. X
  639. "MAKESTARTUP := $(INIT)/dmake.ini",
  640. SHAR_EOF
  641. chmod 0640 dmake/os2/startup.h ||
  642. echo 'restore of dmake/os2/startup.h failed'
  643. Wc_c="`wc -c < 'dmake/os2/startup.h'`"
  644. test 384 -eq "$Wc_c" ||
  645.     echo 'dmake/os2/startup.h: original size 384, current size' "$Wc_c"
  646. rm -f _shar_wnt_.tmp
  647. fi
  648. # ============= dmake/os2/stdarg.h ==============
  649. if test -f 'dmake/os2/stdarg.h' -a X"$1" != X"-c"; then
  650.     echo 'x - skipping dmake/os2/stdarg.h (File already exists)'
  651.     rm -f _shar_wnt_.tmp
  652. else
  653. > _shar_wnt_.tmp
  654. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/stdarg.h' &&
  655. /*
  656. X * stdarg.h
  657. X *
  658. X * defines ANSI style macros for accessing arguments of a function which takes
  659. X * a variable number of arguments
  660. X *
  661. X */
  662. X
  663. #if !defined(__STDARG)
  664. #define __STDARG
  665. X
  666. typedef char *va_list;
  667. X
  668. #define va_dcl int va_alist
  669. #define va_start(ap,v)  ap = (va_list)&va_alist
  670. #define va_arg(ap,t)    ((t*)(ap += sizeof(t)))[-1]
  671. #define va_end(ap)      ap = NULL
  672. #endif
  673. SHAR_EOF
  674. chmod 0640 dmake/os2/stdarg.h ||
  675. echo 'restore of dmake/os2/stdarg.h failed'
  676. Wc_c="`wc -c < 'dmake/os2/stdarg.h'`"
  677. test 373 -eq "$Wc_c" ||
  678.     echo 'dmake/os2/stdarg.h: original size 373, current size' "$Wc_c"
  679. rm -f _shar_wnt_.tmp
  680. fi
  681. # ============= dmake/os2/switchar.c ==============
  682. if test -f 'dmake/os2/switchar.c' -a X"$1" != X"-c"; then
  683.     echo 'x - skipping dmake/os2/switchar.c (File already exists)'
  684.     rm -f _shar_wnt_.tmp
  685. else
  686. > _shar_wnt_.tmp
  687. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/switchar.c' &&
  688. /*
  689. ** return switch char
  690. */
  691. #if defined(OS2) || defined(_MSC_VER)
  692. #include <stdlib.h>
  693. #endif
  694. #if !defined(OS2)
  695. #include <dos.h>
  696. #endif /* !OS2 */
  697. #include <stdio.h>
  698. #include "stdmacs.h"
  699. X
  700. getswitchar()/*
  701. ===============
  702. X   Try the environment first.  If you don't find SWITCHAR there, then use
  703. X   the DOS call.  The call is undocumented, and doesn't work for DOS versions
  704. X   4.0 and up, so the check of the environment will fix that. */
  705. {
  706. #if defined(M_I86)
  707. #if !defined(OS2)
  708. X   union REGS rg;
  709. #endif /* ! OS2 */
  710. X   static char *_env_switchar = NIL(char);
  711. X
  712. X   if( _env_switchar != NIL(char) ||
  713. X       (_env_switchar = (char *)getenv("SWITCHAR")) != NIL(char) )
  714. X      return(*_env_switchar);
  715. X
  716. #if !defined(OS2)
  717. X   rg.h.ah = 0x37;      /* switch char request */
  718. X   rg.h.al = 0;         /* get (not set) */
  719. X
  720. X   intdos(&rg, &rg);
  721. X   return (rg.h.dl);
  722. #endif /* ! OS2 */
  723. #endif /* M_I86 */
  724. X
  725. X   return ('/');
  726. }
  727. SHAR_EOF
  728. chmod 0640 dmake/os2/switchar.c ||
  729. echo 'restore of dmake/os2/switchar.c failed'
  730. Wc_c="`wc -c < 'dmake/os2/switchar.c'`"
  731. test 904 -eq "$Wc_c" ||
  732.     echo 'dmake/os2/switchar.c: original size 904, current size' "$Wc_c"
  733. rm -f _shar_wnt_.tmp
  734. fi
  735. # ============= dmake/os2/sysintf.h ==============
  736. if test -f 'dmake/os2/sysintf.h' -a X"$1" != X"-c"; then
  737.     echo 'x - skipping dmake/os2/sysintf.h (File already exists)'
  738.     rm -f _shar_wnt_.tmp
  739. else
  740. > _shar_wnt_.tmp
  741. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/sysintf.h' &&
  742. /*
  743. ** assorted bits of system interface
  744. */
  745. X
  746. #define STAT stat
  747. #define VOID_LCACHE(l,m)
  748. #define Hook_std_writes(A)
  749. #define GETPID getpid()
  750. X
  751. extern char * tempnam();
  752. extern char * getcwd();
  753. X
  754. /*
  755. ** standard C items
  756. */
  757. X
  758. /*
  759. ** DOS interface standard items
  760. */
  761. #define    chdir(p) _chdir(p)
  762. X
  763. /*
  764. ** make parameters
  765. */
  766. #define    MAX_PATH_LEN    256
  767. X
  768. SHAR_EOF
  769. chmod 0640 dmake/os2/sysintf.h ||
  770. echo 'restore of dmake/os2/sysintf.h failed'
  771. Wc_c="`wc -c < 'dmake/os2/sysintf.h'`"
  772. test 333 -eq "$Wc_c" ||
  773.     echo 'dmake/os2/sysintf.h: original size 333, current size' "$Wc_c"
  774. rm -f _shar_wnt_.tmp
  775. fi
  776. # ============= dmake/parse.c ==============
  777. if test -f 'dmake/parse.c' -a X"$1" != X"-c"; then
  778.     echo 'x - skipping dmake/parse.c (File already exists)'
  779.     rm -f _shar_wnt_.tmp
  780. else
  781. > _shar_wnt_.tmp
  782. sed 's/^X//' << 'SHAR_EOF' > 'dmake/parse.c' &&
  783. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/parse.c,v 1.1 91/05/06 15:23:20 dvadura Exp $
  784. -- SYNOPSIS -- parse the input, and perform semantic analysis
  785. -- 
  786. -- DESCRIPTION
  787. --     This file contains the routines that parse the input makefile and
  788. --    call the appropriate routines to perform the semantic analysis and
  789. --    build the internal dag.
  790. --
  791. -- AUTHOR
  792. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  793. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  794. --
  795. -- COPYRIGHT
  796. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  797. -- 
  798. --      This program is free software; you can redistribute it and/or
  799. --      modify it under the terms of the GNU General Public License
  800. --      (version 1), as published by the Free Software Foundation, and
  801. --      found in the file 'LICENSE' included with this distribution.
  802. -- 
  803. --      This program is distributed in the hope that it will be useful,
  804. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  805. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  806. --      GNU General Public License for more details.
  807. -- 
  808. --      You should have received a copy of the GNU General Public License
  809. --      along with this program;  if not, write to the Free Software
  810. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  811. --
  812. -- LOG
  813. --     $Log:    parse.c,v $
  814. X * Revision 1.1  91/05/06  15:23:20  dvadura
  815. X * dmake Release Version 3.7
  816. X * 
  817. */
  818. X
  819. #include "extern.h"
  820. X
  821. X
  822. PUBLIC void
  823. Parse( fil )/*
  824. ==============  Parse the makefile input */
  825. FILE *fil;
  826. {
  827. X   int  rule  = FALSE;                 /* have seen a recipe line        */
  828. X   char *p;                   /* termporary pointer into Buffer */
  829. X
  830. X   DB_ENTER( "Parse" );
  831. X
  832. X   State = NORMAL_SCAN;
  833. X   Group = FALSE;                 /* true if scanning a group rcpe  */
  834. X   while( TRUE ) {
  835. X      if( Get_line( Buffer, fil ) ) {
  836. X     if( fil != NIL( FILE ) )               /* end of parsable input */
  837. X        Closefile();
  838. X
  839. X     Bind_rules_to_targets( F_DEFAULT );
  840. X         if( Group )  Fatal( "Incomplete rule recipe group detected" );
  841. X
  842. X     DB_VOID_RETURN;
  843. X      }
  844. X      else {
  845. X         switch( State ) {
  846. X        case RULE_SCAN:
  847. X
  848. X           /* Check for the `[' that starts off a group rule definition.  It
  849. X            * must appear as the first non-white space
  850. X        * character in the line. */
  851. X
  852. X           p = _strspn( Buffer, " \t\r\n" );
  853. X               if( Set_group_attributes( p ) ) {
  854. X                  if( rule && Group )
  855. X                     Fatal( "Cannot mix single and group recipe lines" );
  856. X                  else
  857. X                     Group = TRUE;
  858. X
  859. X                  rule = TRUE;
  860. X
  861. X                  break;                     /* ignore the group start  */
  862. X               }
  863. X
  864. X               if( Group ) {
  865. X                  if( *p != ']' ) {
  866. X                     Add_recipe_to_list( Buffer, TRUE, TRUE );
  867. X                     rule = TRUE;
  868. X                  }
  869. X                  else
  870. X                     State = NORMAL_SCAN;
  871. X               }
  872. X               else {
  873. X                  if( *Buffer == '\t' ) {
  874. X                     Add_recipe_to_list( Buffer, FALSE, FALSE );
  875. X                     rule = TRUE;
  876. X                  }
  877. X                  else if( *p == ']' )
  878. X                     Fatal( "Found unmatched ']'" );
  879. X                  else if( *Buffer && *p )
  880. X             State = NORMAL_SCAN;
  881. X               }
  882. X 
  883. X               if( State == RULE_SCAN ) break;     /* ie. keep going    */
  884. X               
  885. X           Bind_rules_to_targets( (Group) ? F_GROUP: F_DEFAULT );
  886. X
  887. X               rule = FALSE;
  888. X               if( Group ) {
  889. X                  Group = FALSE;
  890. X                  break;
  891. X               }
  892. X           /*FALLTRHOUGH*/
  893. X
  894. X               /* In this case we broke out of the rule scan because we do not
  895. X                * have a recipe line that begins with a <TAB>, so lets
  896. X        * try to scan the thing as a macro or rule definition. */
  897. X               
  898. X
  899. X        case NORMAL_SCAN:
  900. X           if( !*Buffer ) continue;         /* we have null input line */
  901. X
  902. X           /* STUPID AUGMAKE uses "include" at the start of a line as
  903. X            * a signal to include a new file, so let's look for it.
  904. X        * if we see it replace it by .INCLUDE: and stick this back
  905. X        * into the buffer. */
  906. X           if( !strncmp( "include", Buffer, 7 ) &&
  907. X           (Buffer[7] == ' ' || Buffer[7] == '\t') )
  908. X           {
  909. X          char *tmp;
  910. X
  911. X          tmp = _strjoin( ".INCLUDE:", Buffer+7, -1, FALSE );
  912. X          strcpy( Buffer, tmp );
  913. X          FREE( tmp );
  914. X           }
  915. X
  916. X               /* look for a macro definition, they all contain an = sign
  917. X            * if we fail to recognize it as a legal macro op then try to
  918. X        * parse the same line as a rule definition, it's one or the
  919. X        * other */
  920. X        
  921. X           if( Parse_macro(Buffer, M_DEFAULT) ) break;/* it's a macro def */
  922. X           if( Parse_rule_def( &State ) )         break;/* it's a rule def  */
  923. X
  924. X           /* if just blank line then ignore it */
  925. X           if( *_strspn( Buffer, " \t\r\n" ) == '\0' ) break;
  926. X           
  927. X           /* otherwise assume it was a line of unrecognized input, or a
  928. X            * recipe line out of place so print a message */
  929. X        
  930. X           Fatal( "Expecting macro or rule defn, found neither" );
  931. X           break;
  932. X
  933. X        default:
  934. X           Fatal( "Internal -- UNKNOWN Parser state %d", State );
  935. X     }
  936. X      }
  937. X   }
  938. }
  939. X
  940. SHAR_EOF
  941. chmod 0640 dmake/parse.c ||
  942. echo 'restore of dmake/parse.c failed'
  943. Wc_c="`wc -c < 'dmake/parse.c'`"
  944. test 5207 -eq "$Wc_c" ||
  945.     echo 'dmake/parse.c: original size 5207, current size' "$Wc_c"
  946. rm -f _shar_wnt_.tmp
  947. fi
  948. # ============= dmake/patchlvl.h ==============
  949. if test -f 'dmake/patchlvl.h' -a X"$1" != X"-c"; then
  950.     echo 'x - skipping dmake/patchlvl.h (File already exists)'
  951.     rm -f _shar_wnt_.tmp
  952. else
  953. > _shar_wnt_.tmp
  954. sed 's/^X//' << 'SHAR_EOF' > 'dmake/patchlvl.h' &&
  955. /* dmake patch level, reset to 0 for each new version release. */
  956. X
  957. #define PATCHLEVEL 0
  958. SHAR_EOF
  959. chmod 0640 dmake/patchlvl.h ||
  960. echo 'restore of dmake/patchlvl.h failed'
  961. Wc_c="`wc -c < 'dmake/patchlvl.h'`"
  962. test 88 -eq "$Wc_c" ||
  963.     echo 'dmake/patchlvl.h: original size 88, current size' "$Wc_c"
  964. rm -f _shar_wnt_.tmp
  965. fi
  966. # ============= dmake/path.c ==============
  967. if test -f 'dmake/path.c' -a X"$1" != X"-c"; then
  968.     echo 'x - skipping dmake/path.c (File already exists)'
  969.     rm -f _shar_wnt_.tmp
  970. else
  971. > _shar_wnt_.tmp
  972. sed 's/^X//' << 'SHAR_EOF' > 'dmake/path.c' &&
  973. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/path.c,v 1.1 91/05/06 15:23:23 dvadura Exp $
  974. -- SYNOPSIS -- pathname manipulation code
  975. -- 
  976. -- DESCRIPTION
  977. --    Pathname routines to handle building and pulling appart
  978. --    pathnames.
  979. -- 
  980. -- AUTHOR
  981. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  982. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  983. --
  984. -- COPYRIGHT
  985. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  986. -- 
  987. --      This program is free software; you can redistribute it and/or
  988. --      modify it under the terms of the GNU General Public License
  989. --      (version 1), as published by the Free Software Foundation, and
  990. --      found in the file 'LICENSE' included with this distribution.
  991. -- 
  992. --      This program is distributed in the hope that it will be useful,
  993. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  994. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  995. --      GNU General Public License for more details.
  996. -- 
  997. --      You should have received a copy of the GNU General Public License
  998. --      along with this program;  if not, write to the Free Software
  999. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1000. --
  1001. -- LOG
  1002. --     $Log:    path.c,v $
  1003. X * Revision 1.1  91/05/06  15:23:23  dvadura
  1004. X * dmake Release Version 3.7
  1005. X * 
  1006. */
  1007. X
  1008. #include "extern.h"
  1009. X
  1010. /*
  1011. ** Return the suffix portion of a filename, assumed to begin with a `.'.
  1012. */
  1013. PUBLIC char *
  1014. Get_suffix(name)
  1015. char *name;
  1016. {
  1017. X   char *suff;
  1018. X
  1019. X   if(name == NIL(char)  || (suff = strrchr(name, '.')) == NIL(char))
  1020. X      suff = ".NULL";
  1021. X
  1022. X   return (suff);
  1023. }
  1024. X
  1025. X
  1026. X
  1027. /*
  1028. ** Take dir and name, and return a path which has dir as the directory
  1029. ** and name afterwards.
  1030. **
  1031. ** N.B. Assumes that the dir separator string is in DirSepStr.
  1032. **      Return path is built in a static buffer, if you need to use it
  1033. **      again you must _strdup the result returned by Build_path.
  1034. */
  1035. PUBLIC char *
  1036. Build_path(dir, name)
  1037. char *dir;
  1038. char *name;
  1039. {
  1040. X   register char *p;
  1041. X   register char *q;
  1042. X   static char     *path  = NIL(char);
  1043. X   static unsigned buflen = 0;
  1044. X   int  plen = 0;
  1045. X   int  dlen = 0;
  1046. X   int  len;
  1047. X
  1048. X   if( dir  != NIL(char) ) dlen = strlen( dir  );
  1049. X   if( name != NIL(char) ) plen = strlen( name );
  1050. X   len = plen+dlen+strlen(DirSepStr)+1;
  1051. X
  1052. X   if( len > buflen ) {
  1053. X      buflen = (len+16) & ~0xf;        /* buf is always multiple of 16 */
  1054. X
  1055. X      if( path == NIL(char) )
  1056. X         path = MALLOC( buflen, char );
  1057. X      else
  1058. X         path = realloc( path, (unsigned) (buflen*sizeof(char)) );
  1059. X   }
  1060. X   
  1061. X   *path = '\0';
  1062. X
  1063. X   if( dlen ) {
  1064. X      strcpy( path, dir );
  1065. X      if( *path && strchr(DirBrkStr, dir[dlen-1]) == NIL(char) )
  1066. X     strcat( path, DirSepStr );
  1067. X   }
  1068. X   strcat( path, name );
  1069. X
  1070. X   q=path;
  1071. X   while( *q ) {
  1072. X      char *t;
  1073. X
  1074. X      p=_strpbrk(q,DirBrkStr);
  1075. X      t=_strpbrk(p+1,DirBrkStr);
  1076. X      if( !*p || !*t ) break;
  1077. X
  1078. X      if(    !(p-q == 2 && strncmp(q,"..",2) == 0)
  1079. X          && t-p-1 == 2 && strncmp(p+1,"..",2) == 0 ) {
  1080. X     t = _strspn(t,DirBrkStr);
  1081. X     strcpy(q,t);
  1082. X      }
  1083. X      else
  1084. X     q = p+1;
  1085. X   }
  1086. X
  1087. X   return( path );
  1088. }
  1089. SHAR_EOF
  1090. chmod 0640 dmake/path.c ||
  1091. echo 'restore of dmake/path.c failed'
  1092. Wc_c="`wc -c < 'dmake/path.c'`"
  1093. test 3063 -eq "$Wc_c" ||
  1094.     echo 'dmake/path.c: original size 3063, current size' "$Wc_c"
  1095. rm -f _shar_wnt_.tmp
  1096. fi
  1097. # ============= dmake/percent.c ==============
  1098. if test -f 'dmake/percent.c' -a X"$1" != X"-c"; then
  1099.     echo 'x - skipping dmake/percent.c (File already exists)'
  1100.     rm -f _shar_wnt_.tmp
  1101. else
  1102. > _shar_wnt_.tmp
  1103. sed 's/^X//' << 'SHAR_EOF' > 'dmake/percent.c' &&
  1104. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/percent.c,v 1.1 91/05/06 15:23:24 dvadura Exp $
  1105. -- SYNOPSIS -- handle building or %-rule meta-target nfa.
  1106. -- 
  1107. -- DESCRIPTION
  1108. --    Builds the NFA used by dmake to match targets against %-meta
  1109. --    rule constructs.  The NFA is built as a set of DFA's.
  1110. -- 
  1111. -- AUTHOR
  1112. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  1113. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  1114. --
  1115. -- COPYRIGHT
  1116. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  1117. -- 
  1118. --      This program is free software; you can redistribute it and/or
  1119. --      modify it under the terms of the GNU General Public License
  1120. --      (version 1), as published by the Free Software Foundation, and
  1121. --      found in the file 'LICENSE' included with this distribution.
  1122. -- 
  1123. --      This program is distributed in the hope that it will be useful,
  1124. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  1125. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1126. --      GNU General Public License for more details.
  1127. -- 
  1128. --      You should have received a copy of the GNU General Public License
  1129. --      along with this program;  if not, write to the Free Software
  1130. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1131. --
  1132. -- LOG
  1133. --     $Log:    percent.c,v $
  1134. X * Revision 1.1  91/05/06  15:23:24  dvadura
  1135. X * dmake Release Version 3.7
  1136. X * 
  1137. */
  1138. X
  1139. #include "extern.h"
  1140. X
  1141. static DFAPTR _build_dfa ANSI((char *));
  1142. static char   _shift_dfa ANSI((DFAPTR, char *));
  1143. X
  1144. X
  1145. #define NO_ACTION    0
  1146. #define START_PERCENT    1
  1147. #define END_PERCENT    2
  1148. #define ACCEPT        4
  1149. #define FAIL           -1
  1150. X
  1151. static  NFAPTR _nfa = NIL( NFA );
  1152. X
  1153. X
  1154. PUBLIC DFALINKPTR
  1155. Match_dfa( buf )/*
  1156. ==================
  1157. X   This routines runs all DFA's in parrallel and selects the one that best
  1158. X   matches the string.  If no match then it returns NIL( DFA ) */
  1159. char *buf;
  1160. {
  1161. X   register NFAPTR nfa;
  1162. X   int         adv;
  1163. X   DFALINKPTR       dfa_list = NIL(DFALINK);
  1164. X
  1165. X   DB_ENTER( "Match_dfa" );
  1166. X   DB_PRINT( "dfa", ("Matching %s", buf) );
  1167. X
  1168. X   /* Run each of the DFA's on the input string in parallel, we terminate
  1169. X    * when all DFA's have either failed or ACCEPTED, if more than one DFA
  1170. X    * accepts we build a list of all accepting DFA's sorted on states with
  1171. X    * those matching in a higher numbered state heading the list. */
  1172. X
  1173. X   do {
  1174. X      adv = FALSE;
  1175. X
  1176. X      for( nfa = _nfa; nfa != NIL( NFA ); nfa = nfa->next )
  1177. X     if( nfa->status != (char) FAIL && nfa->status != (char) ACCEPT ) {
  1178. X        adv++;
  1179. X        nfa->status = _shift_dfa( nfa->dfa, buf );
  1180. X
  1181. X        /* Construct the list of matching DFA's */
  1182. X        if( nfa->status == (char) ACCEPT ) {
  1183. X           DFALINKPTR dl;
  1184. X
  1185. X           TALLOC( dl, 1, DFALINK );
  1186. X           dl->dl_meta  = nfa->dfa->node;
  1187. X           dl->dl_per   = _substr( nfa->dfa->pstart, nfa->dfa->pend );
  1188. X           dl->dl_state = nfa->dfa->states - nfa->dfa->c_state;
  1189. X
  1190. X           if( dfa_list == NIL(DFALINK) )
  1191. X              dfa_list = dl;
  1192. X           else {
  1193. X          DFALINKPTR tdli = dfa_list;
  1194. X          DFALINKPTR tdlp = NIL(DFALINK);
  1195. X
  1196. X          for( ; tdli != NIL(DFALINK); tdli = tdli->dl_next ) {
  1197. X             if( dl->dl_state >= tdli->dl_state )
  1198. X            break;
  1199. X             tdlp = tdli;
  1200. X          }
  1201. X
  1202. X          if( tdli != NIL(DFALINK) ) {
  1203. X             tdli->dl_prev = dl;
  1204. X             dl->dl_next   = tdli;
  1205. X          }
  1206. X
  1207. X          if( tdlp != NIL(DFALINK) ) {
  1208. X             tdlp->dl_next = dl;
  1209. X             dl->dl_prev   = tdlp;
  1210. X          }
  1211. X          else
  1212. X             dfa_list = dl;
  1213. X           }
  1214. X
  1215. X           DB_PRINT( "dfa", ("Matched [%s]", dl->dl_meta->CE_NAME) );
  1216. X        }
  1217. X     }
  1218. X
  1219. X      buf++;
  1220. X   }
  1221. X   while ( adv );
  1222. X
  1223. X   for( nfa = _nfa; nfa != NIL( NFA ); nfa = nfa->next ) {
  1224. X      nfa->status = 0;
  1225. X      nfa->dfa->c_state = nfa->dfa->states;
  1226. X   }
  1227. X
  1228. X   DB_RETURN( dfa_list );
  1229. }
  1230. X
  1231. X
  1232. PUBLIC void
  1233. Check_circle_dfa()/*
  1234. ====================
  1235. X   This function is called to test for circularities in the DFA lists
  1236. X   constructed from %-meta targets. */
  1237. {
  1238. X   register NFAPTR nfa;
  1239. X
  1240. X   for( nfa = _nfa; nfa != NIL(NFA); nfa = nfa->next )
  1241. X      if( Test_circle( nfa->dfa->node, FALSE ) )
  1242. X     Fatal( "Detected circular dependency in inference graph at [%s]",
  1243. X        nfa->dfa->node->CE_NAME );
  1244. }
  1245. X
  1246. X
  1247. PUBLIC void
  1248. Add_nfa( name )/*
  1249. =================
  1250. X   Given name, build a DFA and add it to the NFA.  The NFA is maintained as
  1251. X   a singly linked list of DFA's. */
  1252. char *name;
  1253. {
  1254. X   NFAPTR nfa;
  1255. X
  1256. X   TALLOC(nfa, 1, NFA);
  1257. X   nfa->dfa = _build_dfa(name);
  1258. X
  1259. X   if( _nfa != NIL(NFA) ) nfa->next = _nfa;
  1260. X
  1261. X   _nfa = nfa;
  1262. }
  1263. X
  1264. X
  1265. static DFAPTR
  1266. _build_dfa( name )/*
  1267. ====================
  1268. X   Construct a dfa for the passed in cell name.  The routine returns a struct
  1269. X   that represents a finite state machine that can recognize a regular
  1270. X   expression with exactly one '%' sign in it.  The '%' symbol is used as a
  1271. X   wildcard character that will match anything except the character that
  1272. X   immediately follows it or NUL.
  1273. X
  1274. X   The Construction of DFA's is well know and can be found in Hopcroft and
  1275. X   Ullman or any other book discussing formal language theory.
  1276. X   A more practical treatise can be found in Compilers, Aho, Sethi and Ullman.
  1277. */
  1278. char *name;
  1279. {
  1280. X   DFAPTR   dfa;
  1281. X   int      nstates;
  1282. X   register STATEPTR sp;
  1283. X   STATEPTR per_state = NIL(STATE);
  1284. X   int      pcount=0;
  1285. X   int      end_percent=FALSE;
  1286. X
  1287. X   nstates = strlen(name)+2;
  1288. X
  1289. X   /* Allocate a DFA node and the right number of states. */
  1290. X   TALLOC(dfa, 1, DFA);
  1291. X   TALLOC(sp=dfa->c_state=dfa->states, nstates, STATE);
  1292. X   dfa->node = Def_cell( name );
  1293. X
  1294. X   /* Now construct the state table for the DFA */
  1295. X   do {
  1296. X      if( *name == '%' ) {
  1297. X     if( pcount++ > 0 )
  1298. X        Error( "Only one %% allowed within a %%-meta target" );
  1299. X
  1300. X     sp->symbol   = 0;
  1301. X     sp->action   = START_PERCENT;
  1302. X     sp->no_match = sp->match = per_state = sp+1;
  1303. X     end_percent  = TRUE;
  1304. X      }
  1305. X      else {
  1306. X     sp->symbol   = *name;
  1307. X     sp->no_match = per_state;
  1308. X
  1309. X     if( *name == '\0' ) {
  1310. X        sp->action = ACCEPT;
  1311. X        sp->match  = dfa->states;
  1312. X     }
  1313. X     else {
  1314. X        sp->action = NO_ACTION;
  1315. X        sp->match  = sp+1;
  1316. X     }
  1317. X
  1318. X     if( end_percent ) {
  1319. X        sp->action |= END_PERCENT;
  1320. X        end_percent = FALSE;
  1321. X     }
  1322. X      }
  1323. X      
  1324. X      sp++; 
  1325. X   }
  1326. X   while( *name++ );
  1327. X
  1328. X   return(dfa);
  1329. }
  1330. X
  1331. X
  1332. static char
  1333. _shift_dfa( dfa, data )/*
  1334. =========================
  1335. X   Take a given dfa and advance it based on the current state, the shift
  1336. X   action in that state, and the current data value. */
  1337. DFAPTR dfa;
  1338. char   *data;
  1339. {
  1340. X   register STATEPTR sp = dfa->c_state;
  1341. X   char c = *data;
  1342. X
  1343. X   /* Check if it is a START_PERCENT action if so then we need to save
  1344. X    * a pointer to the start of the string and advance to the next state. */
  1345. X   if( sp->action & START_PERCENT ) {
  1346. X      dfa->pstart = data;
  1347. X      sp++;
  1348. X   }
  1349. X
  1350. X   /* Now check if the current char matches the character expected in the
  1351. X    * current state.  If it does then perform the specified action, otherwise
  1352. X    * either shift it or fail.  We fail if the next state on no-match is
  1353. X    * NIL. */
  1354. X   if( sp->symbol == c ) {
  1355. X      if( sp->action & END_PERCENT ) dfa->pend = data;
  1356. X      if( sp->action & ACCEPT ) return(ACCEPT);
  1357. X      dfa->c_state = sp->match;
  1358. X   }
  1359. X   else if( (dfa->c_state = sp->no_match) == NIL(STATE) || !c )
  1360. X      return(FAIL);
  1361. X
  1362. X   return(NO_ACTION);
  1363. }
  1364. SHAR_EOF
  1365. chmod 0640 dmake/percent.c ||
  1366. echo 'restore of dmake/percent.c failed'
  1367. Wc_c="`wc -c < 'dmake/percent.c'`"
  1368. test 7050 -eq "$Wc_c" ||
  1369.     echo 'dmake/percent.c: original size 7050, current size' "$Wc_c"
  1370. rm -f _shar_wnt_.tmp
  1371. fi
  1372. # ============= dmake/quit.c ==============
  1373. if test -f 'dmake/quit.c' -a X"$1" != X"-c"; then
  1374.     echo 'x - skipping dmake/quit.c (File already exists)'
  1375.     rm -f _shar_wnt_.tmp
  1376. else
  1377. > _shar_wnt_.tmp
  1378. sed 's/^X//' << 'SHAR_EOF' > 'dmake/quit.c' &&
  1379. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/quit.c,v 1.1 91/05/06 15:23:25 dvadura Exp $
  1380. -- SYNOPSIS -- end the dmake session.
  1381. -- 
  1382. -- DESCRIPTION
  1383. --     Handles dmake termination.
  1384. --
  1385. -- AUTHOR
  1386. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  1387. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  1388. --
  1389. -- COPYRIGHT
  1390. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  1391. -- 
  1392. --      This program is free software; you can redistribute it and/or
  1393. --      modify it under the terms of the GNU General Public License
  1394. --      (version 1), as published by the Free Software Foundation, and
  1395. --      found in the file 'LICENSE' included with this distribution.
  1396. -- 
  1397. --      This program is distributed in the hope that it will be useful,
  1398. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  1399. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1400. --      GNU General Public License for more details.
  1401. -- 
  1402. --      You should have received a copy of the GNU General Public License
  1403. --      along with this program;  if not, write to the Free Software
  1404. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1405. --
  1406. -- LOG
  1407. --     $Log:    quit.c,v $
  1408. X * Revision 1.1  91/05/06  15:23:25  dvadura
  1409. X * dmake Release Version 3.7
  1410. X * 
  1411. */
  1412. X
  1413. #include "extern.h"
  1414. X
  1415. static    void    _handle_quit ANSI((char*));
  1416. static    int    _dont_quit = 0;
  1417. X
  1418. X
  1419. PUBLIC void
  1420. Quit()/*
  1421. ======== Error or quit */
  1422. {
  1423. X   if( _dont_quit ) return;
  1424. SHAR_EOF
  1425. true || echo 'restore of dmake/quit.c failed'
  1426. fi
  1427. echo 'End of part 27, continue with part 28'
  1428. echo 28 > _shar_seq_.tmp
  1429. exit 0
  1430.  
  1431. exit 0 # Just in case...
  1432. -- 
  1433. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1434. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1435. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1436. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1437.